package tp.disenio.shared;

import java.io.Serializable;
import javax.persistence.*;
import javax.xml.namespace.QName;

import com.sun.xml.bind.v2.schemagen.xmlschema.Annotated;
import com.sun.xml.bind.v2.schemagen.xmlschema.Annotation;
import com.sun.xml.bind.v2.schemagen.xmlschema.List;
import com.sun.xml.bind.v2.schemagen.xmlschema.SimpleType;
import com.sun.xml.txw2.Document;
import com.sun.xml.txw2.TypedXmlWriter;

import sun.misc.Sort;
import tp.disenio.client.ListarCompetenciasDeportivasUA;
import tp.disenio.controllers.ControlCompetencia;
import tp.disenio.shared.Deporte;
import tp.disenio.shared.Estadodecompetencia;
import tp.disenio.shared.Modalidad;
import tp.disenio.shared.Reglamento;
import tp.disenio.shared.Tipodepuntuacion;
import tp.disenio.shared.Usuario;
import ClasesDAO.CompetenciaDAO;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;


/**
 * The persistent class for the competencia database table.
 * 
 */
@Entity
public class Competencia implements Serializable {
	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="id_competencia")
	private int idCompetencia;

	@Column(name="cantidad_de_sets")
	private int cantidadDeSets;

    @Temporal( TemporalType.DATE)
	@Column(name="fecha_de_eliminacion")
	private Date fechaDeEliminacion;

    @Temporal( TemporalType.DATE)
	@Column(name="hora_de_eliminacion")
	private Date horaDeEliminacion;

	private String nombre;

	@Column(name="permitir_empates")
	private boolean permitirEmpates;

	@Column(name="puntos_partido_empatado")
	private int puntosPartidoEmpatado;

	@Column(name="puntos_partido_ganado")
	private int puntosPartidoGanado;

	@Column(name="puntos_por_presentarse")
	private int puntosPorPresentarse;

	@Column(name="tantos_por_ausencia")
	private int tantosPorAusencia;
		

	//bi-directional many-to-one association to Deporte
    @ManyToOne
    @JoinColumn(name="FK_id_deporte",nullable = false)
	private Deporte deporte;

	//bi-directional many-to-one association to Modalidad
    @ManyToOne
    @JoinColumn(name="FK_id_modalidad", nullable = false)
	private Modalidad modalidad;

	//bi-directional one-to-one association to Reglamento
	@OneToOne(cascade = CascadeType.PERSIST)
	@JoinColumn(name="FK_id_reglamento",nullable = false)
	private Reglamento reglamento;

	//bi-directional many-to-one association to Usuario
    @ManyToOne
    @JoinColumn(name="USUARIO_id_usuario", nullable = false)
	private Usuario usuario;
	
	//bi-directional many-to-one association to Disponibilidad
	@OneToMany(mappedBy="competencia",cascade = CascadeType.PERSIST)
	private Set<Disponibilidad> disponibilidad;

	//bi-directional many-to-one association to Fecha
	@OneToMany(mappedBy="competencia",cascade = CascadeType.PERSIST)
	private Set<Fecha> fechas;
	
	//bi-directional many-to-one association to Participante
	@OneToMany(mappedBy="competencia",cascade = CascadeType.PERSIST)
	private Set<Participante> participantes;

	//bi-directional many-to-one association to Estadodecompetencia
    @ManyToOne
    @JoinColumn(name="FK_id_estado",nullable = false)
	private Estadodecompetencia estadodecompetencia;

	//bi-directional many-to-one association to Tipodepuntuacion
    @ManyToOne
    @JoinColumn(name="FK_id_tipo_puntuacion", nullable = false)
	private Tipodepuntuacion tipodepuntuacion;

	//bi-directional one-to-one association to Tabladeposiciones
	@OneToOne
	@JoinColumn(name="id_competencia",nullable=false,insertable=false, updatable=false)
	private Tabladeposiciones tabladeposiciones;
	
	
	/**
	 * 
	 */
	public Competencia() {
	}
	
	
	/**
	 * 
	 * @param usuario
	 * @param nombre
	 * @param estado
	 * @param deporte
	 * @param modalidad
	 * @param puntos_partido_ganado
	 * @param permitir_empates
	 * @param puntos_partido_empatado
	 * @param puntos_por_presentarse
	 * @param cantidad_sets
	 * @param tantos_por_ausencia
	 * @param tipo_de_puntuacion
	 * @param reglamento
	 */
	public Competencia(Usuario usuario, String nombre, Estadodecompetencia estado, Deporte deporte, Modalidad modalidad, int puntos_partido_ganado,
					   boolean permitir_empates, int puntos_partido_empatado, int puntos_por_presentarse, int cantidad_sets,
					   int tantos_por_ausencia, Tipodepuntuacion tipo_de_puntuacion, Reglamento reglamento){
		
		this.usuario = usuario;
		this.nombre = nombre;
		this.estadodecompetencia = estado;
		this.deporte = deporte;
		this.modalidad = modalidad;
		this.puntosPartidoGanado = puntos_partido_ganado;
		this.permitirEmpates = permitir_empates;
		this.puntosPartidoEmpatado = puntos_partido_empatado;
		this.puntosPorPresentarse = puntos_por_presentarse;
		this.cantidadDeSets = cantidad_sets;
		this.tantosPorAusencia = tantos_por_ausencia;
		this.tipodepuntuacion = tipo_de_puntuacion;
		this.reglamento = reglamento;

	}


	/**
	 * 
	 * @param usuario
	 * @param nombre
	 * @param estado
	 * @param deporte
	 * @param modalidad
	 * @param puntos_partido_ganado
	 * @param permitir_empates
	 * @param puntos_partido_empatado
	 * @param puntos_por_presentarse
	 * @param cantidad_sets
	 * @param tantos_por_ausencia
	 * @param tipoDePuntuacion
	 * @param reglamento
	 */
	public void actualizarCompetencia(Usuario usuario, String nombre,	Estadodecompetencia estado, Deporte deporte, Modalidad modalidad,
									  int puntos_partido_ganado, boolean permitir_empates, int puntos_partido_empatado, int puntos_por_presentarse,
									  int cantidad_sets, int tantos_por_ausencia, Tipodepuntuacion tipoDePuntuacion, Reglamento reglamento) {
		
		this.usuario = usuario;
		this.nombre = nombre;
		this.estadodecompetencia = estado;
		this.deporte = deporte;
		this.modalidad = modalidad;
		this.puntosPartidoGanado = puntos_partido_ganado;
		this.permitirEmpates = permitir_empates;
		this.puntosPartidoEmpatado = puntos_partido_empatado;
		this.puntosPorPresentarse = puntos_por_presentarse;
		this.cantidadDeSets = cantidad_sets;
		this.tantosPorAusencia = tantos_por_ausencia;
		this.tipodepuntuacion = tipoDePuntuacion;
		this.reglamento = reglamento;
		
	}
	

	/**
	 * 
	 * @return
	 */
	public int getIdCompetencia() {
		return this.idCompetencia;
	}

	
	/**
	 * 
	 * @param idCompetencia
	 */
	public void setIdCompetencia(int idCompetencia) {
		this.idCompetencia = idCompetencia;
	}

	
	/**
	 * 
	 * @return
	 */
	public Deporte getDeporte() {
		return this.deporte;
	}

	
	/**
	 * 
	 * @param deporte
	 */
	public void setDeporte(Deporte deporte) {
		this.deporte = deporte;
	}

	
	/**
	 * 
	 * @return
	 */
	public Estadodecompetencia getEstado() {
		return this.estadodecompetencia;
	}

	
	/**
	 * 
	 * @param estado
	 */
	public void setEstado(Estadodecompetencia estado) {
		this.estadodecompetencia = estado;
	}

	
	/**
	 * 
	 * @return
	 */
	public Modalidad getModalidad() {
		return this.modalidad;
	}

	
	/**
	 * 
	 * @param modalidad
	 */
	public void setModalidad(Modalidad modalidad) {
		this.modalidad = modalidad;
	}

	
	/**
	 * 
	 * @return
	 */
	public Tipodepuntuacion getTipoDePuntuacion() {
		return this.tipodepuntuacion;
	}

	
	/**
	 * 
	 * @param tipoDePuntuacion
	 */
	public void setTipoDePuntuacion(Tipodepuntuacion tipoDePuntuacion) {
		this.tipodepuntuacion = tipoDePuntuacion;
	}

	
	/**
	 * 
	 * @return
	 */
	public boolean esLiga() {		
		if (this.modalidad.getNombre().equals("Liga")){
			return true;
		}
		else {
			return false;
		}
	}
	
	
	/**
	 * 
	 * @return
	 */
	public boolean esEliminatoriaSimple() {
		if (this.modalidad.getNombre().equals("Eliminacion Simple")){
			return true;
		}
		else {
			return false;
		}
	}


	/**
	 * 
	 * @return
	 */
	public boolean esEliminatoriaDoble() {
		if (this.modalidad.getNombre().equals("Eliminacion Doble")){
			return true;
		}
		else {
			return false;
		}
	}


	/**
	 * 
	 * @return
	 */
	public boolean estaCreada() {
		if (this.estadodecompetencia.getNombre().equals("Creada")){
			return true;
		}
		else {
			return false;
		}
	}
	
	
	/**
	 * 
	 * @return
	 */
	public boolean estaPlanificada() {
		if (this.estadodecompetencia.getNombre().equals("Planificada")){
			return true;
		}
		else {
			return false;
		}
	}
	
	
	/**
	 * 
	 * @return
	 */
	public Usuario getUsuario() {
		return this.usuario;
	}

	
	/**
	 * 
	 * @param usuario
	 */
	public void setUsuario(Usuario usuario) {
		this.usuario = usuario;
	}

	
	/**
	 * 
	 * @return
	 */
	public String getNombre() {
		return this.nombre;
	}

	
	/**
	 * 
	 * @param nombre
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	
	/**
	 * 
	 * @return
	 */
	public Date getFechaDeEliminacion() {
		return this.fechaDeEliminacion;
	}

	
	/**
	 * 
	 * @param fechaDeEliminacion
	 */
	public void setFechaDeEliminacion(Date fechaDeEliminacion) {
		this.fechaDeEliminacion = fechaDeEliminacion;
	}

	
	/**
	 * 
	 * @return
	 */
	public Date getHoraDeEliminacion() {
		return this.horaDeEliminacion;
	}

	
	/**
	 * 
	 * @param horaDeEliminacion
	 */
	public void setHoraDeEliminacion(Date horaDeEliminacion) {
		this.horaDeEliminacion = horaDeEliminacion;
	}

	
	/**
	 * 
	 * @return
	 */
	public Integer getPuntosPartidoGanado(){
		return this.puntosPartidoGanado;
	}

	
	/**
	 * 
	 * @param puntosPartidoGanado
	 */
	public void setPuntosPartidoGanado(Integer puntosPartidoGanado) {
		this.puntosPartidoGanado = puntosPartidoGanado;
	}

	
	/**
	 * 
	 * @return
	 */
	public Boolean getPermitirEmpates() {
		return this.permitirEmpates;
	}

	
	/**
	 * 
	 * @param permitirEmpates
	 */
	public void setPermitirEmpates(Boolean permitirEmpates) {
		this.permitirEmpates = permitirEmpates;
	}

	
	/**
	 * 
	 * @return
	 */
	public Integer getPuntosPartidoEmpatado() {
		return this.puntosPartidoEmpatado;
	}

	
	/**
	 * 
	 * @param puntosPartidoEmpatado
	 */
	public void setPuntosPartidoEmpatado(Integer puntosPartidoEmpatado) {
		this.puntosPartidoEmpatado = puntosPartidoEmpatado;
	}

	
	/**
	 * 
	 * @return
	 */
	public Integer getPuntosPorPresentarse() {
		return this.puntosPorPresentarse;
	}

	
	/**
	 * 
	 * @param puntosPorPresentarse
	 */
	public void setPuntosPorPresentarse(Integer puntosPorPresentarse) {
		this.puntosPorPresentarse = puntosPorPresentarse;
	}

	
	/**
	 * 
	 * @return
	 */
	public Integer getCantidadDeSets() {
		return this.cantidadDeSets;
	}

	
	/**
	 * 
	 * @param cantidadDeSets
	 */
	public void setCantidadDeSets(Integer cantidadDeSets) {
		this.cantidadDeSets = cantidadDeSets;
	}

	
	/**
	 * 
	 * @return
	 */
	public Integer getTantosPorAusencia() {
		return this.tantosPorAusencia;
	}

	
	/**
	 * 
	 * @param tantosPorAusencia
	 */
	public void setTantosPorAusencia(Integer tantosPorAusencia) {
		this.tantosPorAusencia = tantosPorAusencia;
	}

	
	/**
	 * 
	 * @return
	 */
	public Tabladeposiciones getTablaDePosiciones() {
		return this.tabladeposiciones;
	}

	
	/**
	 * 
	 * @param tablaDePosicioneses
	 */
	public void setTablaDePosiciones(Tabladeposiciones tablaDePosiciones) {
		this.tabladeposiciones = tablaDePosiciones;
	}

	
	/**
	 * 
	 */
	public void cargarTablaDePosiciones(){		
		this.tabladeposiciones = CompetenciaDAO.cargarTablaDePosiciones(this.idCompetencia);	
	}
	
	
	/**
	 * 
	 * @param partido
	 */
	public void agregarResultadoPuntuacionTabla(Partido partido) {
		
		Participante participanteUno = partido.getParticipanteUno();
		Participante participanteDos = partido.getParticipanteDos();		
		
		Resultado resultado = partido.getResultado();
		int resultadoUno = resultado.getPuntuacion().getValorUno();
		int resultadoDos = resultado.getPuntuacion().getValorDos();
		
		Renglontablaposiciones renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteUno);
		
		if (resultadoUno > resultadoDos){
			renglon.actualizarPartidosGanados(1);
			renglon.actualizarPuntaje(this.getPuntosPartidoGanado());
			renglon.actualizarTantosAFavor(resultadoUno);
			renglon.actualizarTantosEnContra(resultadoDos);	
		}
		else if (resultadoUno == resultadoDos){
			renglon.actualizarPartidosEmpatados(1);
			renglon.actualizarPuntaje(this.getPuntosPartidoEmpatado());
			renglon.actualizarTantosAFavor(resultadoUno);
			renglon.actualizarTantosEnContra(resultadoDos);	
		}
		else if (resultadoUno < resultadoDos){
			renglon.actualizarPartidosPerdidos(1);
			renglon.actualizarPuntaje(0);
			renglon.actualizarTantosAFavor(resultadoUno);
			renglon.actualizarTantosEnContra(resultadoDos);	
		}				
		
		////////////////////////////////////////////////////////////////////////////
		renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteDos);
		
		if (resultadoUno < resultadoDos){
			renglon.actualizarPartidosGanados(1);
			renglon.actualizarPuntaje(this.getPuntosPartidoGanado());
			renglon.actualizarTantosAFavor(resultadoDos);
			renglon.actualizarTantosEnContra(resultadoUno);	
		}
		else if (resultadoUno == resultadoDos){
			renglon.actualizarPartidosEmpatados(1);
			renglon.actualizarPuntaje(this.getPuntosPartidoEmpatado());
			renglon.actualizarTantosAFavor(resultadoDos);
			renglon.actualizarTantosEnContra(resultadoUno);	
		}
		else if (resultadoUno > resultadoDos){
			renglon.actualizarPartidosPerdidos(1);
			renglon.actualizarPuntaje(0);
			renglon.actualizarTantosAFavor(resultadoDos);
			renglon.actualizarTantosEnContra(resultadoUno);	
		}		
	}
	
	
	/**
	 * 
	 * @param partido
	 * @param resultadoAnt
	 */
	public void quitarResultadoAntPuntuacionTabla(Partido partido, Resultado resultadoAnt) {
		
		Participante participanteUno = partido.getParticipanteUno();
		Participante participanteDos = partido.getParticipanteDos();		
		
		int resultadoAntUno = resultadoAnt.getPuntuacion().getValorUno();
		int resultadoAntDos = resultadoAnt.getPuntuacion().getValorDos();
		
		Renglontablaposiciones renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteUno);
		
		if ((resultadoAntUno > resultadoAntDos)){
			renglon.actualizarPartidosGanados(-1);
			renglon.actualizarPuntaje(-this.getPuntosPartidoGanado());
			renglon.actualizarTantosAFavor(-resultadoAntUno);
			renglon.actualizarTantosEnContra(-resultadoAntDos);	
		}
		else if (resultadoAntUno == resultadoAntDos){
			renglon.actualizarPartidosEmpatados(-1);
			renglon.actualizarPuntaje(-this.getPuntosPartidoEmpatado());
			renglon.actualizarTantosAFavor(-resultadoAntUno);
			renglon.actualizarTantosEnContra(-resultadoAntDos);	
		}
		else if (resultadoAntUno < resultadoAntDos){
			renglon.actualizarPartidosPerdidos(-1);
			renglon.actualizarPuntaje(0);
			renglon.actualizarTantosAFavor(-resultadoAntUno);
			renglon.actualizarTantosEnContra(-resultadoAntDos);	
		}
		
		////////////////////////////////////////////////////////////////////////////
		renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteDos);
		
		if (resultadoAntUno < resultadoAntDos){
			renglon.actualizarPartidosGanados(-1);
			renglon.actualizarPuntaje(-this.getPuntosPartidoGanado());
			renglon.actualizarTantosAFavor(-resultadoAntDos);
			renglon.actualizarTantosEnContra(-resultadoAntUno);	
		}
		else if (resultadoAntUno == resultadoAntDos){
			renglon.actualizarPartidosEmpatados(-1);
			renglon.actualizarPuntaje(-this.getPuntosPartidoEmpatado());
			renglon.actualizarTantosAFavor(-resultadoAntDos);
			renglon.actualizarTantosEnContra(-resultadoAntUno);	
		}
		else if (resultadoAntUno > resultadoAntDos){
			renglon.actualizarPartidosPerdidos(-1);
			renglon.actualizarPuntaje(0);
			renglon.actualizarTantosAFavor(-resultadoAntDos);
			renglon.actualizarTantosEnContra(-resultadoAntUno);	
		}		
	}
	
	
	/**
	 * 
	 * @param partido
	 */
	public void agregarResultadoFinalTabla(Partido partido) {		
		
		Participante participanteUno = partido.getParticipanteUno();
		Participante participanteDos = partido.getParticipanteDos();		
		
		Resultado resultado = partido.getResultado();
		String condicion = resultado.getResultadofinal().getCondicion();
		
		Renglontablaposiciones renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteUno);
		
		if (condicion.equals("Gano Local")){
			renglon.actualizarPartidosGanados(1);
			renglon.actualizarPuntaje(this.getPuntosPartidoGanado());
		}

		else if (condicion.equals("Gano Visitante")){
			renglon.actualizarPartidosPerdidos(1);
			renglon.actualizarPuntaje(0);
		}				
		
		////////////////////////////////////////////////////////////////////////////
		renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteDos);
		
		if (condicion.equals("Gano Visitante")){
			renglon.actualizarPartidosGanados(1);
			renglon.actualizarPuntaje(this.getPuntosPartidoGanado());
		}

		else if (condicion.equals("Gano Local")){
			renglon.actualizarPartidosPerdidos(1);
			renglon.actualizarPuntaje(0);
		}		
	}
	
	
	/**
	 * 
	 * @param partido
	 */
	public void quitarResultadoAntFinalTabla(Partido partido, Resultado resultadoAnt) {		
		
		Participante participanteUno = partido.getParticipanteUno();
		Participante participanteDos = partido.getParticipanteDos();		
		
		String condicionAnt = resultadoAnt.getResultadofinal().getCondicion();
		
		Renglontablaposiciones renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteUno);
		
		if (condicionAnt.equals("Gano Local")){
			renglon.actualizarPartidosGanados(-1);
			renglon.actualizarPuntaje(-this.getPuntosPartidoGanado());

		}

		else if (condicionAnt.equals("Gano Visitante")){
			renglon.actualizarPartidosPerdidos(-1);
			renglon.actualizarPuntaje(0);
		}
		
		////////////////////////////////////////////////////////////////////////////
		renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteDos);
		
		if (condicionAnt.equals("Gano Visitante")){
			renglon.actualizarPartidosGanados(-1);
			renglon.actualizarPuntaje(-this.getPuntosPartidoGanado());

		}

		else if (condicionAnt.equals("Gano Local")){
			renglon.actualizarPartidosPerdidos(-1);
			renglon.actualizarPuntaje(0);
		}		
	}
	
	
	/**
	 * 
	 * @param partido
	 */
	public void agregarResultadoSetsTabla(Partido partido) {
		
		Participante participanteUno = partido.getParticipanteUno();
		Participante participanteDos = partido.getParticipanteDos();		
		Resultado resultado = partido.getResultado();
		Sets set;
		
		int setsGanadosUno = 0;
		int setsGanadosDos = 0;
		
		for (int i = 0; i < resultado.getSets().size(); i++){
			 set = (Sets)resultado.getSets().get(i);
			
			if (set.getValorUno() < set.getValorDos()){
				setsGanadosUno++;
			}
			else {
				setsGanadosDos++;
			}
		}

		
		Renglontablaposiciones renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteUno);
		
		if (setsGanadosUno > setsGanadosDos){
			renglon.actualizarPartidosGanados(1);
			renglon.actualizarPuntaje(this.getPuntosPartidoGanado());
			renglon.actualizarTantosAFavor(setsGanadosUno);
			renglon.actualizarTantosEnContra(setsGanadosDos);	
		}
		else if (setsGanadosUno == setsGanadosDos){
			renglon.actualizarPartidosEmpatados(1);
			renglon.actualizarPuntaje(this.getPuntosPartidoEmpatado());
			renglon.actualizarTantosAFavor(setsGanadosUno);
			renglon.actualizarTantosEnContra(setsGanadosDos);	
		}
		else if (setsGanadosUno < setsGanadosDos){
			renglon.actualizarPartidosPerdidos(1);
			renglon.actualizarPuntaje(0);
			renglon.actualizarTantosAFavor(setsGanadosUno);
			renglon.actualizarTantosEnContra(setsGanadosDos);	
		}				
		
		////////////////////////////////////////////////////////////////////////////
		renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteDos);
		
		if (setsGanadosUno < setsGanadosDos){
			renglon.actualizarPartidosGanados(1);
			renglon.actualizarPuntaje(this.getPuntosPartidoGanado());
			renglon.actualizarTantosAFavor(setsGanadosUno);
			renglon.actualizarTantosEnContra(setsGanadosDos);	
		}
		else if (setsGanadosUno == setsGanadosDos){
			renglon.actualizarPartidosEmpatados(1);
			renglon.actualizarPuntaje(this.getPuntosPartidoEmpatado());
			renglon.actualizarTantosAFavor(setsGanadosUno);
			renglon.actualizarTantosEnContra(setsGanadosDos);	
		}
		else if (setsGanadosUno > setsGanadosDos){
			renglon.actualizarPartidosPerdidos(1);
			renglon.actualizarPuntaje(0);
			renglon.actualizarTantosAFavor(setsGanadosUno);
			renglon.actualizarTantosEnContra(setsGanadosDos);	
		}
		
	}
	
	
	/**
	 * 
	 * @param partido
	 */
	public void quitarResultadoAntSetsTabla(Partido partido, Resultado resultadoAnt) {
		
		Participante participanteUno = partido.getParticipanteUno();
		Participante participanteDos = partido.getParticipanteDos();
		Resultado resultado = partido.getResultado();
		
		int setsGanadosUno = 0;
		int setsGanadosDos = 0;
		
		for (int i = 0; i < resultado.getSets().size(); i++){
			Sets set = (Sets)resultado.getSets().get(i);
			
			if (set.getValorUno() < set.getValorDos()){
				setsGanadosUno++;
			}
			else {
				setsGanadosDos++;
			}
		}

		
		Renglontablaposiciones renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteUno);
		
		if (setsGanadosUno > setsGanadosDos){
			renglon.actualizarPartidosGanados(-1);
			renglon.actualizarPuntaje(-this.getPuntosPartidoGanado());
			renglon.actualizarTantosAFavor(-setsGanadosUno);
			renglon.actualizarTantosEnContra(-setsGanadosDos);	
		}
		else if (setsGanadosUno == setsGanadosDos){
			renglon.actualizarPartidosEmpatados(-1);
			renglon.actualizarPuntaje(-this.getPuntosPartidoEmpatado());
			renglon.actualizarTantosAFavor(-setsGanadosUno);
			renglon.actualizarTantosEnContra(-setsGanadosDos);	
		}
		else if (setsGanadosUno < setsGanadosDos){
			renglon.actualizarPartidosPerdidos(-1);
			renglon.actualizarPuntaje(0);
			renglon.actualizarTantosAFavor(-setsGanadosUno);
			renglon.actualizarTantosEnContra(-setsGanadosDos);	
		}				
		
		////////////////////////////////////////////////////////////////////////////
		renglon = this.tabladeposiciones.getRenglonPorParticipante(participanteDos);
		
		if (setsGanadosUno < setsGanadosDos){
			renglon.actualizarPartidosGanados(-1);
			renglon.actualizarPuntaje(-this.getPuntosPartidoGanado());
			renglon.actualizarTantosAFavor(-setsGanadosUno);
			renglon.actualizarTantosEnContra(-setsGanadosDos);	
		}
		else if (setsGanadosUno == setsGanadosDos){
			renglon.actualizarPartidosEmpatados(-1);
			renglon.actualizarPuntaje(-this.getPuntosPartidoEmpatado());
			renglon.actualizarTantosAFavor(-setsGanadosUno);
			renglon.actualizarTantosEnContra(-setsGanadosDos);	
		}
		else if (setsGanadosUno > setsGanadosDos){
			renglon.actualizarPartidosPerdidos(-1);
			renglon.actualizarPuntaje(0);
			renglon.actualizarTantosAFavor(-setsGanadosUno);
			renglon.actualizarTantosEnContra(-setsGanadosDos);	
		}
	}

	
	/**
	 * 
	 * @return
	 */
	public ArrayList<Participante> getParticipantes() {
		return new ArrayList<Participante>(this.participantes);
	}

		
	/**
	 * 
	 */
	public void cargarParticipantes() {
		ArrayList<Participante> participantes = CompetenciaDAO.cargarParticipantes(this.idCompetencia);		
		
		this.participantes.clear();
		System.out.println(participantes.size()+"%&/$%&/");
		for (int i = 0; i < participantes.size(); i++){
			this.participantes.add(participantes.get(i));
		}
		
	}	
	
	
	/**
	 * 
	 * @return
	 */
	public int cantidadDeParticipantes() {		
		return this.participantes.size();
	}
	
	
	/**
	 * 
	 * @param participantes
	 */
	public void setParticipantes(ArrayList<Participante> participantes) {
		for (int i = 0; i < participantes.size(); i++){
			this.participantes.add(participantes.get(i));
		}
	}

	
	/**
	 * 
	 * @param participante
	 */
	public void agregarParticipante(Participante participante){
		this.participantes.add(participante);
	}
	
	
	/**
	 * 
	 * @return
	 */
	public ArrayList<Disponibilidad> getDisponibilidades() {		
		return new ArrayList<Disponibilidad>(this.disponibilidad);
	}

	
	/**
	 * 
	 * @param disponibilidades
	 */
	public void setDisponibilidades(ArrayList<Disponibilidad> disponibilidades) {
		for (int i = 0; i < disponibilidades.size(); i++){
			this.disponibilidad.add(disponibilidades.get(i));
		}
	}

	
	/**
	 * 
	 * @param disponibilidad
	 */
	public void agregarDisponibilidad (Disponibilidad disponibilidad){
		
		this.disponibilidad.add(disponibilidad);
	}
	
	
	/**
	 * 
	 * @return
	 */
	public ArrayList<Fecha> getFechas() {
		
		ArrayList<Fecha> fechas = new ArrayList<Fecha>(this.fechas);
		
		return fechas;
	}
	

	/**
	 * 
	 * @param fechas
	 */
	public void setFechas(ArrayList<Fecha> fechas) {
		for (int i = 0; i < fechas.size(); i++){
			this.fechas.add(fechas.get(i));
		}
	}

	
	/**
	 * 
	 * @param fecha
	 */
	public void agregarFecha(Fecha fecha){
		this.fechas.add(fecha);
	}
	

	/**
	 * 
	 */
	public void getProximasFechas(Date fechaActual){	
		ArrayList<Fecha> fechas = CompetenciaDAO.cargarFechas(this.idCompetencia, fechaActual);
		
		for (int i = 0; i < fechas.size(); i++){
			this.fechas.add(fechas.get(i));
		}
	}
	
	
	/**
	 * 
	 */
	public void cargarFechas() {
		ArrayList<Fecha> fechas = CompetenciaDAO.cargarFechas(this.idCompetencia);
		
		this.fechas.clear();
		
		for (int i = 0; i < fechas.size(); i++){
			this.fechas.add(fechas.get(i));
			System.out.println("FECHAID"+fechas.get(i).getIdFecha());
		}
		
	}
	
	
	/**
	 * 
	 * @return
	 */
	public Reglamento getReglamento() {
		return this.reglamento;
	}

	
	public boolean noTieneFechas(){
		
		return this.fechas.isEmpty();
	}
	/**
	 * 
	 * @param reglamento
	 */
	public void setReglamento(Reglamento reglamento) {
		this.reglamento = reglamento;
	}

}